package com.lsh.netty.websocket;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import io.netty.handler.codec.http.websocketx.*;
import io.netty.util.CharsetUtil;
import lombok.extern.slf4j.Slf4j;

import java.util.Date;

/**
 * @author ：LiuShihao
 * @date ：Created in 2021/6/28 12:28 下午
 * @desc ：
 */
@Slf4j
public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> {
    private WebSocketServerHandshaker handshaker;
    @Override
    protected void messageReceived(ChannelHandlerContext ctx, Object msg) throws Exception {
        //传统http接入：第一次握手消息有HTTP协议承载，所以它是一个HTTP消息，，执行handleHTTPRequest方法来处理WebSocket握手请求
        if (msg instanceof FullHttpRequest){
            handleHttpRequest(ctx,(FullHttpRequest) msg);
        }else if (msg instanceof WebSocketFrame){
        //WebSocket接入：链路建立成功后的操作
            handleWebSocketFrame(ctx,(WebSocketFrame) msg);
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }
    /**
     *
     * 处理WebSocket握手请求
     * @param ctx
     * @param req
     * @throws Exception
     */
    private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) throws Exception {
        // 如果解码失败返回异常
        // 对握手消息进行判断，消息头中没有包含Upgrade字段或者它的值不是websocket 则返回HTTP400响应
        if (!req.decoderResult().isSuccess() || (!"websocket".equals(req.headers().get("Upgrade")))){
            sendHttpResponse(ctx,req,new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
            return;
        }
        //握手请求简单校验通过后，开始构造握手工厂，
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory("ws://localhost:8080/websocket", null, false);
        //创建握手处理类WebSocketServerHandshaker，通过它构造握手响应消息返回给客户端
        //同时将WebSocket相关的编码和解码类动态的添加到 ChannelPipeline中，用于WebSocket消息的编解码
        //添加了WebSocket Encoder 和 WebSocket Decoder 之后，服务端就可以自动对WebSocket消息进行编解码了，后面的业务handler可以直接对WebSocket对象进行操作
        handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null){
            WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        }else {
            handshaker.handshake(ctx.channel(),req);
        }
    }

    /**
     * 客户端通过文本框提交请求消息给服务端，WebSocketServerHandler接收到的已经是解码后的WebSocketFrame消息了（WebSocket握手应答时动态增加了编解码handler）。
     * 首先需要对控制帧进行判断：如果是关闭链路的控制消息，就调用WebSocketServerHandlershaker的close方法关闭WebSocket连接
     * 如果是维持链路的Ping消息，则构造Pong消息返回
     * 本例程的WebSocket通信双方使用的都是文本消息，所以对请求消息的类型进行判断，不是文本的抛出异常。
     * 最后，从TextWebSocketFrame中获取请求消息字符串，对它处理后构造新的TextWebSocketFrame消息返回给客户端，
     * 由于握手应答时动态增加了TextWebSocketFrame的编码类，所以，可以直接发送TextWebSocketFrame对象。
     * @param ctx
     * @param fream
     * @throws Exception
     */
    private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame fream) throws Exception {
        //判断是否关闭链路的指令
        if (fream instanceof CloseWebSocketFrame){
            handshaker.close(ctx.channel(),((CloseWebSocketFrame) fream).retain());
            return;
        }
        //判断是否是Ping消息
        if (fream instanceof PingWebSocketFrame){
            ctx.channel().write(new PongWebSocketFrame(fream.content().retain()));
            return;
        }
        //本实例只支持文本消息，不支持二进制消息
        if (! (fream instanceof TextWebSocketFrame)){
            throw new UnsupportedOperationException(String.format("%s frame types not supported",fream.getClass().getName()));
        }

        //返回应答消息
        String request = ((TextWebSocketFrame) fream).text();
        System.out.println("request:"+request);

        ctx.channel().write(new TextWebSocketFrame(request+", 欢迎使用Netty WebSocket 服务，现在时刻："+new Date().toString()));

    }

    /**
     * 返回响应
     * @param ctx
     * @param req
     * @param response
     */
    private void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req, DefaultFullHttpResponse response) {
        //返回应答给客户端

        if(response.status().code() != 200){
            ByteBuf buf = Unpooled.copiedBuffer(response.status().toString(), CharsetUtil.UTF_8);
            response.content().writeBytes(buf);
            buf.release();
            //注意：此处设置请求头 response.content().readableBytes() 返回int类型
            response.headers().set("Content-Length",String.valueOf(response.content().readableBytes()));
        }
        //如果是非Keep-Alive ，关闭连接
        ChannelFuture f = ctx.channel().writeAndFlush(response);
        if (!req.headers().get("Connection").equals("keep-alive") || response.status().code() != 200){
            f.addListener(ChannelFutureListener.CLOSE);
        }

    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
